//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS ServiceQuotas service.
///
/// With Service Quotas, you can view and manage your quotas easily as your Amazon Web Services workloads grow. Quotas, also referred to as limits, are the maximum number of resources that you can create in your Amazon Web Services account. For more information, see the Service Quotas User Guide. You need Amazon Web Services CLI version 2.13.20 or higher to view and manage resource-level quotas such as Instances per domain for Amazon OpenSearch Service.
public struct ServiceQuotas: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the ServiceQuotas client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            amzTarget: "ServiceQuotasV20190624",
            serviceName: "ServiceQuotas",
            serviceIdentifier: "servicequotas",
            serviceProtocol: .json(version: "1.1"),
            apiVersion: "2019-06-24",
            endpoint: endpoint,
            variantEndpoints: Self.variantEndpoints,
            errorType: ServiceQuotasErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }




    /// FIPS and dualstack endpoints
    static var variantEndpoints: [EndpointVariantType: AWSServiceConfig.EndpointVariant] {[
        [.fips]: .init(endpoints: [
            "us-gov-east-1": "servicequotas.us-gov-east-1.amazonaws.com",
            "us-gov-west-1": "servicequotas.us-gov-west-1.amazonaws.com"
        ])
    ]}

    // MARK: API Calls

    /// Associates your quota request template with your organization. When a new Amazon Web Services account is created in your organization, the quota increase requests in the template are automatically applied to the account. You can add a quota increase request for any adjustable quota to your template.
    @Sendable
    @inlinable
    public func associateServiceQuotaTemplate(_ input: AssociateServiceQuotaTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateServiceQuotaTemplateResponse {
        try await self.client.execute(
            operation: "AssociateServiceQuotaTemplate", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates your quota request template with your organization. When a new Amazon Web Services account is created in your organization, the quota increase requests in the template are automatically applied to the account. You can add a quota increase request for any adjustable quota to your template.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func associateServiceQuotaTemplate(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateServiceQuotaTemplateResponse {
        let input = AssociateServiceQuotaTemplateRequest(
        )
        return try await self.associateServiceQuotaTemplate(input, logger: logger)
    }

    /// Creates a Support case for an existing quota increase request. This call only creates  a Support case if the request has a Pending status.
    @Sendable
    @inlinable
    public func createSupportCase(_ input: CreateSupportCaseRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateSupportCaseResponse {
        try await self.client.execute(
            operation: "CreateSupportCase", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a Support case for an existing quota increase request. This call only creates  a Support case if the request has a Pending status.
    ///
    /// Parameters:
    ///   - requestId: The ID of the pending quota increase request for which you want to open a Support case.
    ///   - logger: Logger use during operation
    @inlinable
    public func createSupportCase(
        requestId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateSupportCaseResponse {
        let input = CreateSupportCaseRequest(
            requestId: requestId
        )
        return try await self.createSupportCase(input, logger: logger)
    }

    /// Deletes the quota increase request for the specified quota from your quota request template.
    @Sendable
    @inlinable
    public func deleteServiceQuotaIncreaseRequestFromTemplate(_ input: DeleteServiceQuotaIncreaseRequestFromTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteServiceQuotaIncreaseRequestFromTemplateResponse {
        try await self.client.execute(
            operation: "DeleteServiceQuotaIncreaseRequestFromTemplate", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the quota increase request for the specified quota from your quota request template.
    ///
    /// Parameters:
    ///   - awsRegion: Specifies the Amazon Web Services Region for which the request was made.
    ///   - quotaCode: Specifies the quota identifier. To find the quota code for a specific  quota, use the ListServiceQuotas operation, and look for the QuotaCode response in the output for the quota you want.
    ///   - serviceCode: Specifies the service identifier. To find the service code value  for an Amazon Web Services service, use the ListServices operation.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteServiceQuotaIncreaseRequestFromTemplate(
        awsRegion: String,
        quotaCode: String,
        serviceCode: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteServiceQuotaIncreaseRequestFromTemplateResponse {
        let input = DeleteServiceQuotaIncreaseRequestFromTemplateRequest(
            awsRegion: awsRegion, 
            quotaCode: quotaCode, 
            serviceCode: serviceCode
        )
        return try await self.deleteServiceQuotaIncreaseRequestFromTemplate(input, logger: logger)
    }

    /// Disables your quota request template. After a template is disabled, the quota increase requests in the template are not applied to new Amazon Web Services accounts in your organization. Disabling a quota request template does not apply its quota increase requests.
    @Sendable
    @inlinable
    public func disassociateServiceQuotaTemplate(_ input: DisassociateServiceQuotaTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateServiceQuotaTemplateResponse {
        try await self.client.execute(
            operation: "DisassociateServiceQuotaTemplate", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disables your quota request template. After a template is disabled, the quota increase requests in the template are not applied to new Amazon Web Services accounts in your organization. Disabling a quota request template does not apply its quota increase requests.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateServiceQuotaTemplate(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateServiceQuotaTemplateResponse {
        let input = DisassociateServiceQuotaTemplateRequest(
        )
        return try await self.disassociateServiceQuotaTemplate(input, logger: logger)
    }

    /// Retrieves the default value for the specified quota. The default value does not reflect any quota increases.
    @Sendable
    @inlinable
    public func getAWSDefaultServiceQuota(_ input: GetAWSDefaultServiceQuotaRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAWSDefaultServiceQuotaResponse {
        try await self.client.execute(
            operation: "GetAWSDefaultServiceQuota", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the default value for the specified quota. The default value does not reflect any quota increases.
    ///
    /// Parameters:
    ///   - quotaCode: Specifies the quota identifier. To find the quota code for a specific  quota, use the ListServiceQuotas operation, and look for the QuotaCode response in the output for the quota you want.
    ///   - serviceCode: Specifies the service identifier. To find the service code value  for an Amazon Web Services service, use the ListServices operation.
    ///   - logger: Logger use during operation
    @inlinable
    public func getAWSDefaultServiceQuota(
        quotaCode: String,
        serviceCode: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAWSDefaultServiceQuotaResponse {
        let input = GetAWSDefaultServiceQuotaRequest(
            quotaCode: quotaCode, 
            serviceCode: serviceCode
        )
        return try await self.getAWSDefaultServiceQuota(input, logger: logger)
    }

    /// Retrieves the status of the association for the quota request template.
    @Sendable
    @inlinable
    public func getAssociationForServiceQuotaTemplate(_ input: GetAssociationForServiceQuotaTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAssociationForServiceQuotaTemplateResponse {
        try await self.client.execute(
            operation: "GetAssociationForServiceQuotaTemplate", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the status of the association for the quota request template.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func getAssociationForServiceQuotaTemplate(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAssociationForServiceQuotaTemplateResponse {
        let input = GetAssociationForServiceQuotaTemplateRequest(
        )
        return try await self.getAssociationForServiceQuotaTemplate(input, logger: logger)
    }

    /// Retrieves information about the specified quota increase request.
    @Sendable
    @inlinable
    public func getRequestedServiceQuotaChange(_ input: GetRequestedServiceQuotaChangeRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetRequestedServiceQuotaChangeResponse {
        try await self.client.execute(
            operation: "GetRequestedServiceQuotaChange", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the specified quota increase request.
    ///
    /// Parameters:
    ///   - requestId: Specifies the ID of the quota increase request.
    ///   - logger: Logger use during operation
    @inlinable
    public func getRequestedServiceQuotaChange(
        requestId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetRequestedServiceQuotaChangeResponse {
        let input = GetRequestedServiceQuotaChangeRequest(
            requestId: requestId
        )
        return try await self.getRequestedServiceQuotaChange(input, logger: logger)
    }

    /// Retrieves the applied quota value for the specified account-level or resource-level quota. For some quotas, only the default values are available. If the applied quota value is not available for a quota, the quota is not retrieved.
    @Sendable
    @inlinable
    public func getServiceQuota(_ input: GetServiceQuotaRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetServiceQuotaResponse {
        try await self.client.execute(
            operation: "GetServiceQuota", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the applied quota value for the specified account-level or resource-level quota. For some quotas, only the default values are available. If the applied quota value is not available for a quota, the quota is not retrieved.
    ///
    /// Parameters:
    ///   - contextId: Specifies the resource with an Amazon Resource Name (ARN).
    ///   - quotaCode: Specifies the quota identifier. To find the quota code for a specific  quota, use the ListServiceQuotas operation, and look for the QuotaCode response in the output for the quota you want.
    ///   - serviceCode: Specifies the service identifier. To find the service code value  for an Amazon Web Services service, use the ListServices operation.
    ///   - logger: Logger use during operation
    @inlinable
    public func getServiceQuota(
        contextId: String? = nil,
        quotaCode: String,
        serviceCode: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetServiceQuotaResponse {
        let input = GetServiceQuotaRequest(
            contextId: contextId, 
            quotaCode: quotaCode, 
            serviceCode: serviceCode
        )
        return try await self.getServiceQuota(input, logger: logger)
    }

    /// Retrieves information about the specified quota increase request in your quota request template.
    @Sendable
    @inlinable
    public func getServiceQuotaIncreaseRequestFromTemplate(_ input: GetServiceQuotaIncreaseRequestFromTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetServiceQuotaIncreaseRequestFromTemplateResponse {
        try await self.client.execute(
            operation: "GetServiceQuotaIncreaseRequestFromTemplate", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the specified quota increase request in your quota request template.
    ///
    /// Parameters:
    ///   - awsRegion: Specifies the Amazon Web Services Region for which you made the request.
    ///   - quotaCode: Specifies the quota identifier. To find the quota code for a specific  quota, use the ListServiceQuotas operation, and look for the QuotaCode response in the output for the quota you want.
    ///   - serviceCode: Specifies the service identifier. To find the service code value  for an Amazon Web Services service, use the ListServices operation.
    ///   - logger: Logger use during operation
    @inlinable
    public func getServiceQuotaIncreaseRequestFromTemplate(
        awsRegion: String,
        quotaCode: String,
        serviceCode: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetServiceQuotaIncreaseRequestFromTemplateResponse {
        let input = GetServiceQuotaIncreaseRequestFromTemplateRequest(
            awsRegion: awsRegion, 
            quotaCode: quotaCode, 
            serviceCode: serviceCode
        )
        return try await self.getServiceQuotaIncreaseRequestFromTemplate(input, logger: logger)
    }

    /// Lists the default values for the quotas for the specified Amazon Web Services service. A default value does not reflect any quota increases.
    @Sendable
    @inlinable
    public func listAWSDefaultServiceQuotas(_ input: ListAWSDefaultServiceQuotasRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAWSDefaultServiceQuotasResponse {
        try await self.client.execute(
            operation: "ListAWSDefaultServiceQuotas", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the default values for the quotas for the specified Amazon Web Services service. A default value does not reflect any quota increases.
    ///
    /// Parameters:
    ///   - maxResults: Specifies the maximum number of results that you want included on each  page of the response. If you do not include this parameter, it defaults to a value appropriate  to the operation. If additional items exist beyond those included in the current response, the  NextToken response element is present and has a value (is not null). Include that  value as the NextToken request parameter in the next call to the operation to get  the next part of the results.  An API operation can return fewer results than the maximum even when there are  more results available. You should check NextToken after every operation to ensure  that you receive all of the results.
    ///   - nextToken: Specifies a value for receiving additional results after you  receive a NextToken response in a previous request. A NextToken  response indicates that more output is available. Set this parameter to the value of the previous  call's NextToken response to indicate where the output should continue  from.
    ///   - serviceCode: Specifies the service identifier. To find the service code value  for an Amazon Web Services service, use the ListServices operation.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAWSDefaultServiceQuotas(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        serviceCode: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAWSDefaultServiceQuotasResponse {
        let input = ListAWSDefaultServiceQuotasRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            serviceCode: serviceCode
        )
        return try await self.listAWSDefaultServiceQuotas(input, logger: logger)
    }

    /// Retrieves the quota increase requests for the specified Amazon Web Services service. Filter responses to return quota requests at  either the account level, resource level, or all levels. Responses include any open or closed requests within 90 days.
    @Sendable
    @inlinable
    public func listRequestedServiceQuotaChangeHistory(_ input: ListRequestedServiceQuotaChangeHistoryRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListRequestedServiceQuotaChangeHistoryResponse {
        try await self.client.execute(
            operation: "ListRequestedServiceQuotaChangeHistory", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the quota increase requests for the specified Amazon Web Services service. Filter responses to return quota requests at  either the account level, resource level, or all levels. Responses include any open or closed requests within 90 days.
    ///
    /// Parameters:
    ///   - maxResults: Specifies the maximum number of results that you want included on each  page of the response. If you do not include this parameter, it defaults to a value appropriate  to the operation. If additional items exist beyond those included in the current response, the  NextToken response element is present and has a value (is not null). Include that  value as the NextToken request parameter in the next call to the operation to get  the next part of the results.  An API operation can return fewer results than the maximum even when there are  more results available. You should check NextToken after every operation to ensure  that you receive all of the results.
    ///   - nextToken: Specifies a value for receiving additional results after you  receive a NextToken response in a previous request. A NextToken  response indicates that more output is available. Set this parameter to the value of the previous  call's NextToken response to indicate where the output should continue  from.
    ///   - quotaRequestedAtLevel: Filters the response to return quota requests for the ACCOUNT, RESOURCE, or ALL levels. ACCOUNT is the default.
    ///   - serviceCode: Specifies the service identifier. To find the service code value  for an Amazon Web Services service, use the ListServices operation.
    ///   - status: Specifies that you want to filter the results to only the requests with the matching status.
    ///   - logger: Logger use during operation
    @inlinable
    public func listRequestedServiceQuotaChangeHistory(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        quotaRequestedAtLevel: AppliedLevelEnum? = nil,
        serviceCode: String? = nil,
        status: RequestStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListRequestedServiceQuotaChangeHistoryResponse {
        let input = ListRequestedServiceQuotaChangeHistoryRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            quotaRequestedAtLevel: quotaRequestedAtLevel, 
            serviceCode: serviceCode, 
            status: status
        )
        return try await self.listRequestedServiceQuotaChangeHistory(input, logger: logger)
    }

    /// Retrieves the quota increase requests for the specified quota. Filter responses to return quota requests at either the account level, resource level, or all levels.
    @Sendable
    @inlinable
    public func listRequestedServiceQuotaChangeHistoryByQuota(_ input: ListRequestedServiceQuotaChangeHistoryByQuotaRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListRequestedServiceQuotaChangeHistoryByQuotaResponse {
        try await self.client.execute(
            operation: "ListRequestedServiceQuotaChangeHistoryByQuota", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the quota increase requests for the specified quota. Filter responses to return quota requests at either the account level, resource level, or all levels.
    ///
    /// Parameters:
    ///   - maxResults: Specifies the maximum number of results that you want included on each  page of the response. If you do not include this parameter, it defaults to a value appropriate  to the operation. If additional items exist beyond those included in the current response, the  NextToken response element is present and has a value (is not null). Include that  value as the NextToken request parameter in the next call to the operation to get  the next part of the results.  An API operation can return fewer results than the maximum even when there are  more results available. You should check NextToken after every operation to ensure  that you receive all of the results.
    ///   - nextToken: Specifies a value for receiving additional results after you  receive a NextToken response in a previous request. A NextToken  response indicates that more output is available. Set this parameter to the value of the previous  call's NextToken response to indicate where the output should continue  from.
    ///   - quotaCode: Specifies the quota identifier. To find the quota code for a specific  quota, use the ListServiceQuotas operation, and look for the QuotaCode response in the output for the quota you want.
    ///   - quotaRequestedAtLevel: Filters the response to return quota requests for the ACCOUNT, RESOURCE, or ALL levels. ACCOUNT is the default.
    ///   - serviceCode: Specifies the service identifier. To find the service code value  for an Amazon Web Services service, use the ListServices operation.
    ///   - status: Specifies that you want to filter the results to only the requests with the matching status.
    ///   - logger: Logger use during operation
    @inlinable
    public func listRequestedServiceQuotaChangeHistoryByQuota(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        quotaCode: String,
        quotaRequestedAtLevel: AppliedLevelEnum? = nil,
        serviceCode: String,
        status: RequestStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListRequestedServiceQuotaChangeHistoryByQuotaResponse {
        let input = ListRequestedServiceQuotaChangeHistoryByQuotaRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            quotaCode: quotaCode, 
            quotaRequestedAtLevel: quotaRequestedAtLevel, 
            serviceCode: serviceCode, 
            status: status
        )
        return try await self.listRequestedServiceQuotaChangeHistoryByQuota(input, logger: logger)
    }

    /// Lists the quota increase requests in the specified quota request template.
    @Sendable
    @inlinable
    public func listServiceQuotaIncreaseRequestsInTemplate(_ input: ListServiceQuotaIncreaseRequestsInTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListServiceQuotaIncreaseRequestsInTemplateResponse {
        try await self.client.execute(
            operation: "ListServiceQuotaIncreaseRequestsInTemplate", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the quota increase requests in the specified quota request template.
    ///
    /// Parameters:
    ///   - awsRegion: Specifies the Amazon Web Services Region for which you made the request.
    ///   - maxResults: Specifies the maximum number of results that you want included on each  page of the response. If you do not include this parameter, it defaults to a value appropriate  to the operation. If additional items exist beyond those included in the current response, the  NextToken response element is present and has a value (is not null). Include that  value as the NextToken request parameter in the next call to the operation to get  the next part of the results.  An API operation can return fewer results than the maximum even when there are  more results available. You should check NextToken after every operation to ensure  that you receive all of the results.
    ///   - nextToken: Specifies a value for receiving additional results after you  receive a NextToken response in a previous request. A NextToken  response indicates that more output is available. Set this parameter to the value of the previous  call's NextToken response to indicate where the output should continue  from.
    ///   - serviceCode: Specifies the service identifier. To find the service code value  for an Amazon Web Services service, use the ListServices operation.
    ///   - logger: Logger use during operation
    @inlinable
    public func listServiceQuotaIncreaseRequestsInTemplate(
        awsRegion: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        serviceCode: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListServiceQuotaIncreaseRequestsInTemplateResponse {
        let input = ListServiceQuotaIncreaseRequestsInTemplateRequest(
            awsRegion: awsRegion, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            serviceCode: serviceCode
        )
        return try await self.listServiceQuotaIncreaseRequestsInTemplate(input, logger: logger)
    }

    /// Lists the applied quota values for the specified Amazon Web Services service. For some quotas, only the default values are available. If the applied quota value is not available for a quota, the quota is not retrieved. Filter responses to return applied quota values at either the account level, resource level, or all levels.
    @Sendable
    @inlinable
    public func listServiceQuotas(_ input: ListServiceQuotasRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListServiceQuotasResponse {
        try await self.client.execute(
            operation: "ListServiceQuotas", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the applied quota values for the specified Amazon Web Services service. For some quotas, only the default values are available. If the applied quota value is not available for a quota, the quota is not retrieved. Filter responses to return applied quota values at either the account level, resource level, or all levels.
    ///
    /// Parameters:
    ///   - maxResults: Specifies the maximum number of results that you want included on each  page of the response. If you do not include this parameter, it defaults to a value appropriate  to the operation. If additional items exist beyond those included in the current response, the  NextToken response element is present and has a value (is not null). Include that  value as the NextToken request parameter in the next call to the operation to get  the next part of the results.  An API operation can return fewer results than the maximum even when there are  more results available. You should check NextToken after every operation to ensure  that you receive all of the results.
    ///   - nextToken: Specifies a value for receiving additional results after you  receive a NextToken response in a previous request. A NextToken  response indicates that more output is available. Set this parameter to the value of the previous  call's NextToken response to indicate where the output should continue  from.
    ///   - quotaAppliedAtLevel: Filters the response to return applied quota values for the ACCOUNT, RESOURCE, or ALL levels. ACCOUNT is the default.
    ///   - quotaCode: Specifies the quota identifier. To find the quota code for a specific  quota, use the ListServiceQuotas operation, and look for the QuotaCode response in the output for the quota you want.
    ///   - serviceCode: Specifies the service identifier. To find the service code value  for an Amazon Web Services service, use the ListServices operation.
    ///   - logger: Logger use during operation
    @inlinable
    public func listServiceQuotas(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        quotaAppliedAtLevel: AppliedLevelEnum? = nil,
        quotaCode: String? = nil,
        serviceCode: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListServiceQuotasResponse {
        let input = ListServiceQuotasRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            quotaAppliedAtLevel: quotaAppliedAtLevel, 
            quotaCode: quotaCode, 
            serviceCode: serviceCode
        )
        return try await self.listServiceQuotas(input, logger: logger)
    }

    /// Lists the names and codes for the Amazon Web Services services integrated with Service Quotas.
    @Sendable
    @inlinable
    public func listServices(_ input: ListServicesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListServicesResponse {
        try await self.client.execute(
            operation: "ListServices", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the names and codes for the Amazon Web Services services integrated with Service Quotas.
    ///
    /// Parameters:
    ///   - maxResults: Specifies the maximum number of results that you want included on each  page of the response. If you do not include this parameter, it defaults to a value appropriate  to the operation. If additional items exist beyond those included in the current response, the  NextToken response element is present and has a value (is not null). Include that  value as the NextToken request parameter in the next call to the operation to get  the next part of the results.  An API operation can return fewer results than the maximum even when there are  more results available. You should check NextToken after every operation to ensure  that you receive all of the results.
    ///   - nextToken: Specifies a value for receiving additional results after you  receive a NextToken response in a previous request. A NextToken  response indicates that more output is available. Set this parameter to the value of the previous  call's NextToken response to indicate where the output should continue  from.
    ///   - logger: Logger use during operation
    @inlinable
    public func listServices(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListServicesResponse {
        let input = ListServicesRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listServices(input, logger: logger)
    }

    /// Returns a list of the tags assigned to the specified applied quota.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of the tags assigned to the specified applied quota.
    ///
    /// Parameters:
    ///   - resourceARN: The Amazon Resource Name (ARN) for the applied quota for which you want to list tags. You can get this information by using the Service Quotas console, or by listing the quotas using the list-service-quotas CLI command or the ListServiceQuotas Amazon Web Services API operation.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceARN: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceARN: resourceARN
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Adds a quota increase request to your quota request template.
    @Sendable
    @inlinable
    public func putServiceQuotaIncreaseRequestIntoTemplate(_ input: PutServiceQuotaIncreaseRequestIntoTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> PutServiceQuotaIncreaseRequestIntoTemplateResponse {
        try await self.client.execute(
            operation: "PutServiceQuotaIncreaseRequestIntoTemplate", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Adds a quota increase request to your quota request template.
    ///
    /// Parameters:
    ///   - awsRegion: Specifies the Amazon Web Services Region to which the template applies.
    ///   - desiredValue: Specifies the new, increased value for the quota.
    ///   - quotaCode: Specifies the quota identifier. To find the quota code for a specific  quota, use the ListServiceQuotas operation, and look for the QuotaCode response in the output for the quota you want.
    ///   - serviceCode: Specifies the service identifier. To find the service code value  for an Amazon Web Services service, use the ListServices operation.
    ///   - logger: Logger use during operation
    @inlinable
    public func putServiceQuotaIncreaseRequestIntoTemplate(
        awsRegion: String,
        desiredValue: Double,
        quotaCode: String,
        serviceCode: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PutServiceQuotaIncreaseRequestIntoTemplateResponse {
        let input = PutServiceQuotaIncreaseRequestIntoTemplateRequest(
            awsRegion: awsRegion, 
            desiredValue: desiredValue, 
            quotaCode: quotaCode, 
            serviceCode: serviceCode
        )
        return try await self.putServiceQuotaIncreaseRequestIntoTemplate(input, logger: logger)
    }

    /// Submits a quota increase request for the specified quota at the account or resource level.
    @Sendable
    @inlinable
    public func requestServiceQuotaIncrease(_ input: RequestServiceQuotaIncreaseRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RequestServiceQuotaIncreaseResponse {
        try await self.client.execute(
            operation: "RequestServiceQuotaIncrease", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Submits a quota increase request for the specified quota at the account or resource level.
    ///
    /// Parameters:
    ///   - contextId: Specifies the resource with an Amazon Resource Name (ARN).
    ///   - desiredValue: Specifies the new, increased value for the quota.
    ///   - quotaCode: Specifies the quota identifier. To find the quota code for a specific  quota, use the ListServiceQuotas operation, and look for the QuotaCode response in the output for the quota you want.
    ///   - serviceCode: Specifies the service identifier. To find the service code value  for an Amazon Web Services service, use the ListServices operation.
    ///   - supportCaseAllowed: Specifies if an Amazon Web Services Support case can be opened for the quota increase request. This parameter is optional.  By default, this flag is set to True and Amazon Web Services may create a support case for some quota increase requests.  You can set this flag to False  if you do not want a support case created when you request a quota increase. If you set the flag to False,  Amazon Web Services does not open a support case and updates the request status to Not approved.
    ///   - logger: Logger use during operation
    @inlinable
    public func requestServiceQuotaIncrease(
        contextId: String? = nil,
        desiredValue: Double,
        quotaCode: String,
        serviceCode: String,
        supportCaseAllowed: Bool? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RequestServiceQuotaIncreaseResponse {
        let input = RequestServiceQuotaIncreaseRequest(
            contextId: contextId, 
            desiredValue: desiredValue, 
            quotaCode: quotaCode, 
            serviceCode: serviceCode, 
            supportCaseAllowed: supportCaseAllowed
        )
        return try await self.requestServiceQuotaIncrease(input, logger: logger)
    }

    /// Adds tags to the specified applied quota. You can include one or more tags to add to the quota.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceResponse {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Adds tags to the specified applied quota. You can include one or more tags to add to the quota.
    ///
    /// Parameters:
    ///   - resourceARN: The Amazon Resource Name (ARN) for the applied quota. You can get this information by using the Service Quotas console, or by listing the quotas using the list-service-quotas CLI command or the ListServiceQuotas Amazon Web Services API operation.
    ///   - tags: The tags that you want to add to the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceARN: String,
        tags: [Tag],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceResponse {
        let input = TagResourceRequest(
            resourceARN: resourceARN, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Removes tags from the specified applied quota. You can specify one or more tags to remove.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceResponse {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes tags from the specified applied quota. You can specify one or more tags to remove.
    ///
    /// Parameters:
    ///   - resourceARN: The Amazon Resource Name (ARN) for the applied quota that you want to untag. You can get this information by using the Service Quotas console, or by listing the quotas using the list-service-quotas CLI command or the ListServiceQuotas Amazon Web Services API operation.
    ///   - tagKeys: The keys of the tags that you want to remove from the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceARN: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceResponse {
        let input = UntagResourceRequest(
            resourceARN: resourceARN, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }
}

extension ServiceQuotas {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: ServiceQuotas, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension ServiceQuotas {
    /// Return PaginatorSequence for operation ``listAWSDefaultServiceQuotas(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAWSDefaultServiceQuotasPaginator(
        _ input: ListAWSDefaultServiceQuotasRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAWSDefaultServiceQuotasRequest, ListAWSDefaultServiceQuotasResponse> {
        return .init(
            input: input,
            command: self.listAWSDefaultServiceQuotas,
            inputKey: \ListAWSDefaultServiceQuotasRequest.nextToken,
            outputKey: \ListAWSDefaultServiceQuotasResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAWSDefaultServiceQuotas(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: Specifies the maximum number of results that you want included on each  page of the response. If you do not include this parameter, it defaults to a value appropriate  to the operation. If additional items exist beyond those included in the current response, the  NextToken response element is present and has a value (is not null). Include that  value as the NextToken request parameter in the next call to the operation to get  the next part of the results.  An API operation can return fewer results than the maximum even when there are  more results available. You should check NextToken after every operation to ensure  that you receive all of the results.
    ///   - serviceCode: Specifies the service identifier. To find the service code value  for an Amazon Web Services service, use the ListServices operation.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAWSDefaultServiceQuotasPaginator(
        maxResults: Int? = nil,
        serviceCode: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAWSDefaultServiceQuotasRequest, ListAWSDefaultServiceQuotasResponse> {
        let input = ListAWSDefaultServiceQuotasRequest(
            maxResults: maxResults, 
            serviceCode: serviceCode
        )
        return self.listAWSDefaultServiceQuotasPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listRequestedServiceQuotaChangeHistory(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listRequestedServiceQuotaChangeHistoryPaginator(
        _ input: ListRequestedServiceQuotaChangeHistoryRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListRequestedServiceQuotaChangeHistoryRequest, ListRequestedServiceQuotaChangeHistoryResponse> {
        return .init(
            input: input,
            command: self.listRequestedServiceQuotaChangeHistory,
            inputKey: \ListRequestedServiceQuotaChangeHistoryRequest.nextToken,
            outputKey: \ListRequestedServiceQuotaChangeHistoryResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listRequestedServiceQuotaChangeHistory(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: Specifies the maximum number of results that you want included on each  page of the response. If you do not include this parameter, it defaults to a value appropriate  to the operation. If additional items exist beyond those included in the current response, the  NextToken response element is present and has a value (is not null). Include that  value as the NextToken request parameter in the next call to the operation to get  the next part of the results.  An API operation can return fewer results than the maximum even when there are  more results available. You should check NextToken after every operation to ensure  that you receive all of the results.
    ///   - quotaRequestedAtLevel: Filters the response to return quota requests for the ACCOUNT, RESOURCE, or ALL levels. ACCOUNT is the default.
    ///   - serviceCode: Specifies the service identifier. To find the service code value  for an Amazon Web Services service, use the ListServices operation.
    ///   - status: Specifies that you want to filter the results to only the requests with the matching status.
    ///   - logger: Logger used for logging
    @inlinable
    public func listRequestedServiceQuotaChangeHistoryPaginator(
        maxResults: Int? = nil,
        quotaRequestedAtLevel: AppliedLevelEnum? = nil,
        serviceCode: String? = nil,
        status: RequestStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListRequestedServiceQuotaChangeHistoryRequest, ListRequestedServiceQuotaChangeHistoryResponse> {
        let input = ListRequestedServiceQuotaChangeHistoryRequest(
            maxResults: maxResults, 
            quotaRequestedAtLevel: quotaRequestedAtLevel, 
            serviceCode: serviceCode, 
            status: status
        )
        return self.listRequestedServiceQuotaChangeHistoryPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listRequestedServiceQuotaChangeHistoryByQuota(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listRequestedServiceQuotaChangeHistoryByQuotaPaginator(
        _ input: ListRequestedServiceQuotaChangeHistoryByQuotaRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListRequestedServiceQuotaChangeHistoryByQuotaRequest, ListRequestedServiceQuotaChangeHistoryByQuotaResponse> {
        return .init(
            input: input,
            command: self.listRequestedServiceQuotaChangeHistoryByQuota,
            inputKey: \ListRequestedServiceQuotaChangeHistoryByQuotaRequest.nextToken,
            outputKey: \ListRequestedServiceQuotaChangeHistoryByQuotaResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listRequestedServiceQuotaChangeHistoryByQuota(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: Specifies the maximum number of results that you want included on each  page of the response. If you do not include this parameter, it defaults to a value appropriate  to the operation. If additional items exist beyond those included in the current response, the  NextToken response element is present and has a value (is not null). Include that  value as the NextToken request parameter in the next call to the operation to get  the next part of the results.  An API operation can return fewer results than the maximum even when there are  more results available. You should check NextToken after every operation to ensure  that you receive all of the results.
    ///   - quotaCode: Specifies the quota identifier. To find the quota code for a specific  quota, use the ListServiceQuotas operation, and look for the QuotaCode response in the output for the quota you want.
    ///   - quotaRequestedAtLevel: Filters the response to return quota requests for the ACCOUNT, RESOURCE, or ALL levels. ACCOUNT is the default.
    ///   - serviceCode: Specifies the service identifier. To find the service code value  for an Amazon Web Services service, use the ListServices operation.
    ///   - status: Specifies that you want to filter the results to only the requests with the matching status.
    ///   - logger: Logger used for logging
    @inlinable
    public func listRequestedServiceQuotaChangeHistoryByQuotaPaginator(
        maxResults: Int? = nil,
        quotaCode: String,
        quotaRequestedAtLevel: AppliedLevelEnum? = nil,
        serviceCode: String,
        status: RequestStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListRequestedServiceQuotaChangeHistoryByQuotaRequest, ListRequestedServiceQuotaChangeHistoryByQuotaResponse> {
        let input = ListRequestedServiceQuotaChangeHistoryByQuotaRequest(
            maxResults: maxResults, 
            quotaCode: quotaCode, 
            quotaRequestedAtLevel: quotaRequestedAtLevel, 
            serviceCode: serviceCode, 
            status: status
        )
        return self.listRequestedServiceQuotaChangeHistoryByQuotaPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listServiceQuotaIncreaseRequestsInTemplate(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listServiceQuotaIncreaseRequestsInTemplatePaginator(
        _ input: ListServiceQuotaIncreaseRequestsInTemplateRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListServiceQuotaIncreaseRequestsInTemplateRequest, ListServiceQuotaIncreaseRequestsInTemplateResponse> {
        return .init(
            input: input,
            command: self.listServiceQuotaIncreaseRequestsInTemplate,
            inputKey: \ListServiceQuotaIncreaseRequestsInTemplateRequest.nextToken,
            outputKey: \ListServiceQuotaIncreaseRequestsInTemplateResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listServiceQuotaIncreaseRequestsInTemplate(_:logger:)``.
    ///
    /// - Parameters:
    ///   - awsRegion: Specifies the Amazon Web Services Region for which you made the request.
    ///   - maxResults: Specifies the maximum number of results that you want included on each  page of the response. If you do not include this parameter, it defaults to a value appropriate  to the operation. If additional items exist beyond those included in the current response, the  NextToken response element is present and has a value (is not null). Include that  value as the NextToken request parameter in the next call to the operation to get  the next part of the results.  An API operation can return fewer results than the maximum even when there are  more results available. You should check NextToken after every operation to ensure  that you receive all of the results.
    ///   - serviceCode: Specifies the service identifier. To find the service code value  for an Amazon Web Services service, use the ListServices operation.
    ///   - logger: Logger used for logging
    @inlinable
    public func listServiceQuotaIncreaseRequestsInTemplatePaginator(
        awsRegion: String? = nil,
        maxResults: Int? = nil,
        serviceCode: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListServiceQuotaIncreaseRequestsInTemplateRequest, ListServiceQuotaIncreaseRequestsInTemplateResponse> {
        let input = ListServiceQuotaIncreaseRequestsInTemplateRequest(
            awsRegion: awsRegion, 
            maxResults: maxResults, 
            serviceCode: serviceCode
        )
        return self.listServiceQuotaIncreaseRequestsInTemplatePaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listServiceQuotas(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listServiceQuotasPaginator(
        _ input: ListServiceQuotasRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListServiceQuotasRequest, ListServiceQuotasResponse> {
        return .init(
            input: input,
            command: self.listServiceQuotas,
            inputKey: \ListServiceQuotasRequest.nextToken,
            outputKey: \ListServiceQuotasResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listServiceQuotas(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: Specifies the maximum number of results that you want included on each  page of the response. If you do not include this parameter, it defaults to a value appropriate  to the operation. If additional items exist beyond those included in the current response, the  NextToken response element is present and has a value (is not null). Include that  value as the NextToken request parameter in the next call to the operation to get  the next part of the results.  An API operation can return fewer results than the maximum even when there are  more results available. You should check NextToken after every operation to ensure  that you receive all of the results.
    ///   - quotaAppliedAtLevel: Filters the response to return applied quota values for the ACCOUNT, RESOURCE, or ALL levels. ACCOUNT is the default.
    ///   - quotaCode: Specifies the quota identifier. To find the quota code for a specific  quota, use the ListServiceQuotas operation, and look for the QuotaCode response in the output for the quota you want.
    ///   - serviceCode: Specifies the service identifier. To find the service code value  for an Amazon Web Services service, use the ListServices operation.
    ///   - logger: Logger used for logging
    @inlinable
    public func listServiceQuotasPaginator(
        maxResults: Int? = nil,
        quotaAppliedAtLevel: AppliedLevelEnum? = nil,
        quotaCode: String? = nil,
        serviceCode: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListServiceQuotasRequest, ListServiceQuotasResponse> {
        let input = ListServiceQuotasRequest(
            maxResults: maxResults, 
            quotaAppliedAtLevel: quotaAppliedAtLevel, 
            quotaCode: quotaCode, 
            serviceCode: serviceCode
        )
        return self.listServiceQuotasPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listServices(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listServicesPaginator(
        _ input: ListServicesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListServicesRequest, ListServicesResponse> {
        return .init(
            input: input,
            command: self.listServices,
            inputKey: \ListServicesRequest.nextToken,
            outputKey: \ListServicesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listServices(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: Specifies the maximum number of results that you want included on each  page of the response. If you do not include this parameter, it defaults to a value appropriate  to the operation. If additional items exist beyond those included in the current response, the  NextToken response element is present and has a value (is not null). Include that  value as the NextToken request parameter in the next call to the operation to get  the next part of the results.  An API operation can return fewer results than the maximum even when there are  more results available. You should check NextToken after every operation to ensure  that you receive all of the results.
    ///   - logger: Logger used for logging
    @inlinable
    public func listServicesPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListServicesRequest, ListServicesResponse> {
        let input = ListServicesRequest(
            maxResults: maxResults
        )
        return self.listServicesPaginator(input, logger: logger)
    }
}

extension ServiceQuotas.ListAWSDefaultServiceQuotasRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> ServiceQuotas.ListAWSDefaultServiceQuotasRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            serviceCode: self.serviceCode
        )
    }
}

extension ServiceQuotas.ListRequestedServiceQuotaChangeHistoryByQuotaRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> ServiceQuotas.ListRequestedServiceQuotaChangeHistoryByQuotaRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            quotaCode: self.quotaCode,
            quotaRequestedAtLevel: self.quotaRequestedAtLevel,
            serviceCode: self.serviceCode,
            status: self.status
        )
    }
}

extension ServiceQuotas.ListRequestedServiceQuotaChangeHistoryRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> ServiceQuotas.ListRequestedServiceQuotaChangeHistoryRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            quotaRequestedAtLevel: self.quotaRequestedAtLevel,
            serviceCode: self.serviceCode,
            status: self.status
        )
    }
}

extension ServiceQuotas.ListServiceQuotaIncreaseRequestsInTemplateRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> ServiceQuotas.ListServiceQuotaIncreaseRequestsInTemplateRequest {
        return .init(
            awsRegion: self.awsRegion,
            maxResults: self.maxResults,
            nextToken: token,
            serviceCode: self.serviceCode
        )
    }
}

extension ServiceQuotas.ListServiceQuotasRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> ServiceQuotas.ListServiceQuotasRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            quotaAppliedAtLevel: self.quotaAppliedAtLevel,
            quotaCode: self.quotaCode,
            serviceCode: self.serviceCode
        )
    }
}

extension ServiceQuotas.ListServicesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> ServiceQuotas.ListServicesRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}
